package com.yang.stream;

import java.io.*;

/**
 * 演示流式输出和非流式输出的更实际应用场景
 */
public class StreamingExample {

    public static void main(String[] args) {
        System.out.println("文件处理示例：");
        
        String testContent = "这是一个测试文件内容。\n包含多行文本。\n用于演示流式处理和非流式处理。\n第四行文本。\n第五行文本。";
        
        // 创建测试文件
        try {
            createTestFile("test_input.txt", testContent);
        } catch (IOException e) {
            System.err.println("无法创建测试文件: " + e.getMessage());
            return;
        }
        
        System.out.println("\n----------流式处理文件----------");
        try {
            processFileStreaming("test_input.txt", "streaming_output.txt");
        } catch (IOException e) {
            System.err.println("流式处理失败: " + e.getMessage());
        }
        
        System.out.println("\n----------非流式处理文件----------");
        try {
            processFileNonStreaming("test_input.txt", "non_streaming_output.txt");
        } catch (IOException e) {
            System.err.println("非流式处理失败: " + e.getMessage());
        }
    }
    
    /**
     * 创建测试文件
     */
    private static void createTestFile(String filename, String content) throws IOException {
        try (FileWriter writer = new FileWriter(filename)) {
            writer.write(content);
        }
        System.out.println("已创建测试文件: " + filename);
    }
    
    /**
     * 流式处理文件 - 边读边处理边写入
     * 适用于处理大文件，因为不需要一次性加载全部内容到内存
     */
    private static void processFileStreaming(String inputFile, String outputFile) throws IOException {
        System.out.println("开始流式处理文件...");
        
        try (BufferedReader reader = new BufferedReader(new FileReader(inputFile));
             BufferedWriter writer = new BufferedWriter(new FileWriter(outputFile))) {
            
            String line;
            int lineCount = 0;
            
            while ((line = reader.readLine()) != null) {
                lineCount++;
                
                // 处理每一行数据
                String processedLine = "行 " + lineCount + " 处理结果: " + line.toUpperCase();
                
                // 立即写入输出文件
                writer.write(processedLine);
                writer.newLine();
                writer.flush(); // 确保立即写入
                
                System.out.println("已处理并输出第 " + lineCount + " 行");
                
                // 模拟处理延迟
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
        
        System.out.println("流式处理完成，输出已保存到 " + outputFile);
    }
    
    /**
     * 非流式处理文件 - 先读取全部内容，处理完成后再一次性写入
     * 不适合处理大文件，因为需要将全部内容加载到内存
     */
    private static void processFileNonStreaming(String inputFile, String outputFile) throws IOException {
        System.out.println("开始非流式处理文件...");
        
        // 先读取全部内容到内存
        StringBuilder allContent = new StringBuilder();
        try (BufferedReader reader = new BufferedReader(new FileReader(inputFile))) {
            String line;
            int lineCount = 0;
            
            while ((line = reader.readLine()) != null) {
                lineCount++;
                System.out.println("读取第 " + lineCount + " 行");
                allContent.append(line).append("\n");
                
                // 模拟处理延迟
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
        
        System.out.println("全部内容已读取完毕，开始处理...");
        
        // 处理全部内容
        String[] lines = allContent.toString().split("\n");
        StringBuilder processedContent = new StringBuilder();
        
        for (int i = 0; i < lines.length; i++) {
            String processedLine = "行 " + (i + 1) + " 处理结果: " + lines[i].toUpperCase();
            processedContent.append(processedLine).append("\n");
            
            System.out.println("正在处理第 " + (i + 1) + " 行");
            
            // 模拟处理延迟
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        
        System.out.println("处理完成，准备一次性写入文件...");
        
        // 一次性写入所有处理后的内容
        try (FileWriter writer = new FileWriter(outputFile)) {
            writer.write(processedContent.toString());
        }
        
        System.out.println("非流式处理完成，输出已保存到 " + outputFile);
    }
} 